/*
  算法

从 promiseAll 函数返回一个新 Promise。
如果输入数组为空，立即用一个空数组解析它并返回。
初始化一个数组 res 以保存结果，最初填充为 null。
初始化一个 resolvedCount 变量，用于跟踪已解析的 Promise 数。
迭代 Promise 返回函数的数组。对于每个返回 Promise 的函数：
在 async/await 版本中，等待 Promise。在解析时，将结果放入 res 数组中的相应位置并增加 resolvedCount。如果引发错误，立即用错误拒绝 Promise。
在 then/catch 版本中，附加一个 then 子句和一个 catch 子句。在解析时，then 子句将结果放入 res 数组中并增加 resolvedCount。catch 子句用错误拒绝 Promise。

*/

var promiseAll = function(functions) {
  return new Promise((resolve, reject) => {
    if (functions.length === 0) {
      resolve([]);
      return;
    }

    const res = new Array(functions.length).fill(null);
    let resolvedCount = 0;

    functions.forEach(async (fn, index) => {
      try {
        const subRes = await fn();
        res[index] = subRes;
        resolvedCount++;
        if (resolvedCount === functions.length) {
          resolve(res);
        }
      } catch(err) {
        reject(err)
      }
    });
  })
};


// test
const functions = [
  () => new Promise(resolve => setTimeout(() => resolve(4), 50)), 
  () => new Promise(resolve => setTimeout(() => resolve(10), 150)), 
  // () => new Promise((resolve, reject) => setTimeout(() => reject(33333), 150)), 
  () => new Promise(resolve => setTimeout(() => resolve(16), 100))
];

(async () => {
  try {
    const result = await promiseAll(functions);
    console.log(result); // 应输出: [4, 10, 16]
  } catch (err) {
    console.error(err);
  }
})();


const myPromiseAll = function(promises) {
  return new Promise((resolve, reject) => {
    if (promises.length === 0) {
      resolve([]);
      return;
    }

    const res = new Array(promises.length).fill(null);
    let count = 0;

    promises.forEach(async (fn, index) => {
      try {
        const subRes = await fn();
        count++;
        res[index] = subRes;
        if (count === promises.length) {
          resolve(res)
        }
      } catch(err) {
        reject(err);
      }
    })
  })
}
